const WebSocket = require('ws');
const express = require('express');
const http = require('http');
const path = require('path');
const app = express();
const server = http.createServer(app);
const fetch = require('node-fetch');
const { initDatabase, testConnection, saveData, queryData, deleteData } = require('./database');
const PDFGenerator = require('./pdf-generator-final-fix');
let wss;

// 配置
const AI_API_URL = 'https://open.bigmodel.cn/api/paas/v4/chat/completions';
const AI_API_KEY = '39547335286d43c1ad31ed7f1b346551.Uegv5VqokkfWg77A'; // 直接设置API密钥

// 解析JSON请求体
app.use(express.json());

// 静态文件服务
app.use(express.static(path.join(__dirname, '../frontend')));

// 中文PDF测试页面
app.get('/test-pdf', (req, res) => {
    res.sendFile(path.join(__dirname, 'test_chinese_pdf.html'));
});

// AI聊天API接口
app.post('/api/ai/chat', async (req, res) => {
  try {
    const { messages } = req.body;

    if (!messages || !Array.isArray(messages)) {
      return res.status(400).json({ error: '无效的消息格式' });
    }

    console.log('收到AI聊天请求:', { messagesCount: messages.length }); // 调试日志
    
    // 调用智谱AI API
    const response = await fetch(AI_API_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${AI_API_KEY}`
      },
      body: JSON.stringify({
        model: 'glm-4-plus',
        messages: messages,
        temperature: 0.7,
        top_p: 0.9,
        max_tokens: 2000
      })
    });
    
    if (!response.ok) {
      console.error('智谱AI API HTTP错误:', response.status, response.statusText);
      return res.status(500).json({ error: `智谱AI API错误: ${response.status} ${response.statusText}` });
    }

    const data = await response.json();
    console.log('智谱AI API响应:', data); // 调试日志

    if (data.error) {
      console.error('智谱AI API错误:', data.error);
      return res.status(500).json({ error: data.error.message || '智谱AI服务错误' });
    }
    
    if (data.choices && data.choices[0] && data.choices[0].message) {
      return res.json({ content: data.choices[0].message.content });
    } else {
      return res.status(500).json({ error: '智谱AI返回了意外的响应格式' });
    }
  } catch (error) {
    console.error('AI API处理错误:', error);
    res.status(500).json({ error: error.message || '服务器内部错误' });
  }
});

// AI API测试端点
app.get('/api/ai/test', async (req, res) => {
  try {
    const testMessages = [
      {
        role: 'system',
        content: '你是一个AI助手。'
      },
      {
        role: 'user',
        content: '你好'
      }
    ];

    const response = await fetch(AI_API_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${AI_API_KEY}`
      },
      body: JSON.stringify({
        model: 'glm-4-plus',
        messages: testMessages,
        temperature: 0.7,
        max_tokens: 100
      })
    });

    const data = await response.json();

    if (response.ok && data.choices && data.choices[0]) {
      res.json({
        success: true,
        message: 'AI API连接正常',
        response: data.choices[0].message.content
      });
    } else {
      res.status(500).json({
        success: false,
        error: data.error || '未知错误',
        status: response.status
      });
    }
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// 数据保存API接口
app.post('/api/data/save', async (req, res) => {
  try {
    const { dataType, value, timestamp, deviceId } = req.body;

    // 数据验证
    if (!dataType || typeof dataType !== 'string') {
      return res.status(400).json({ error: '数据类型不能为空且必须为字符串' });
    }

    if (value === undefined || value === null || typeof value !== 'number' || isNaN(value)) {
      return res.status(400).json({ error: '数据值必须为有效数字' });
    }

    // 验证数据类型是否为支持的类型
    const validDataTypes = ['Heart', 'DropRate', 'Temperature', 'n_spo2'];
    if (!validDataTypes.includes(dataType)) {
      return res.status(400).json({ error: `不支持的数据类型，支持的类型：${validDataTypes.join(', ')}` });
    }

    // 验证数据值范围
    const dataRanges = {
      'Heart': { min: 30, max: 200 },
      'DropRate': { min: 0, max: 200 },
      'Temperature': { min: 20, max: 50 },
      'n_spo2': { min: 70, max: 100 }
    };

    const range = dataRanges[dataType];
    if (value < range.min || value > range.max) {
      return res.status(400).json({
        error: `${dataType}数据值超出有效范围 (${range.min}-${range.max})`
      });
    }

    // 验证时间戳
    const finalTimestamp = timestamp || Date.now();
    if (typeof finalTimestamp !== 'number' || finalTimestamp <= 0) {
      return res.status(400).json({ error: '时间戳必须为有效的正整数' });
    }

    // 保存数据
    const result = await saveData(dataType, value, finalTimestamp, deviceId || 'default');

    return res.json({
      success: true,
      message: '数据保存成功',
      data: result
    });

  } catch (error) {
    console.error('数据保存API错误:', error);
    res.status(500).json({ error: error.message || '数据保存失败' });
  }
});

// 数据查询API接口
app.get('/api/data/query', async (req, res) => {
  try {
    const {
      dataTypes,
      startTime,
      endTime,
      limit = 1000,
      offset = 0,
      deviceId
    } = req.query;

    // 参数验证和转换
    const queryOptions = {};

    // 处理数据类型筛选
    if (dataTypes) {
      if (typeof dataTypes === 'string') {
        queryOptions.dataTypes = dataTypes.split(',').map(type => type.trim());
      } else if (Array.isArray(dataTypes)) {
        queryOptions.dataTypes = dataTypes;
      } else {
        return res.status(400).json({ error: '数据类型参数格式错误' });
      }

      // 验证数据类型
      const validDataTypes = ['Heart', 'DropRate', 'Temperature', 'n_spo2'];
      const invalidTypes = queryOptions.dataTypes.filter(type => !validDataTypes.includes(type));
      if (invalidTypes.length > 0) {
        return res.status(400).json({
          error: `不支持的数据类型：${invalidTypes.join(', ')}`
        });
      }
    }

    // 处理时间范围
    if (startTime) {
      const startTimeNum = parseInt(startTime);
      if (isNaN(startTimeNum) || startTimeNum < 0) {
        return res.status(400).json({ error: '开始时间必须为有效的非负整数' });
      }
      queryOptions.startTime = startTimeNum;
    }

    if (endTime) {
      const endTimeNum = parseInt(endTime);
      if (isNaN(endTimeNum) || endTimeNum < 0) {
        return res.status(400).json({ error: '结束时间必须为有效的非负整数' });
      }
      queryOptions.endTime = endTimeNum;
    }

    // 验证时间范围逻辑
    if (queryOptions.startTime && queryOptions.endTime && queryOptions.startTime > queryOptions.endTime) {
      return res.status(400).json({ error: '开始时间不能大于结束时间' });
    }

    // 处理分页参数
    const limitNum = parseInt(limit);
    const offsetNum = parseInt(offset);

    if (isNaN(limitNum) || limitNum <= 0 || limitNum > 10000) {
      return res.status(400).json({ error: '限制数量必须为1-10000之间的正整数' });
    }

    if (isNaN(offsetNum) || offsetNum < 0) {
      return res.status(400).json({ error: '偏移量必须为非负整数' });
    }

    queryOptions.limit = limitNum;
    queryOptions.offset = offsetNum;

    // 处理设备ID
    if (deviceId) {
      queryOptions.deviceId = deviceId;
    }

    // 查询数据
    const result = await queryData(queryOptions);

    return res.json({
      success: true,
      data: result.data,
      count: result.total,
      currentPage: Math.floor(offsetNum / limitNum) + 1,
      pageSize: limitNum,
      totalPages: Math.ceil(result.total / limitNum),
      query: queryOptions
    });

  } catch (error) {
    console.error('数据查询API错误:', error);
    res.status(500).json({ error: error.message || '数据查询失败' });
  }
});

// 数据删除API接口
app.delete('/api/data/clear', async (req, res) => {
  try {
    console.log('收到数据清空请求:', req.body); // 调试日志

    const {
      dataTypes,
      startTime,
      endTime,
      deviceId,
      confirmDelete
    } = req.body;

    // 安全确认
    if (!confirmDelete) {
      return res.status(400).json({
        error: '删除操作需要确认，请设置confirmDelete为true'
      });
    }

    // 参数验证和转换
    const deleteOptions = {};

    // 处理数据类型筛选
    if (dataTypes) {
      if (typeof dataTypes === 'string') {
        deleteOptions.dataTypes = dataTypes.split(',').map(type => type.trim());
      } else if (Array.isArray(dataTypes)) {
        deleteOptions.dataTypes = dataTypes;
      } else {
        return res.status(400).json({ error: '数据类型参数格式错误' });
      }

      // 验证数据类型
      const validDataTypes = ['Heart', 'DropRate', 'Temperature', 'n_spo2'];
      const invalidTypes = deleteOptions.dataTypes.filter(type => !validDataTypes.includes(type));
      if (invalidTypes.length > 0) {
        return res.status(400).json({
          error: `不支持的数据类型：${invalidTypes.join(', ')}`
        });
      }
    }

    // 处理时间范围
    if (startTime) {
      const startTimeNum = parseInt(startTime);
      if (isNaN(startTimeNum) || startTimeNum < 0) {
        return res.status(400).json({ error: '开始时间必须为有效的非负整数' });
      }
      deleteOptions.startTime = startTimeNum;
    }

    if (endTime) {
      const endTimeNum = parseInt(endTime);
      if (isNaN(endTimeNum) || endTimeNum < 0) {
        return res.status(400).json({ error: '结束时间必须为有效的非负整数' });
      }
      deleteOptions.endTime = endTimeNum;
    }

    // 验证时间范围逻辑
    if (deleteOptions.startTime && deleteOptions.endTime && deleteOptions.startTime > deleteOptions.endTime) {
      return res.status(400).json({ error: '开始时间不能大于结束时间' });
    }

    // 处理设备ID
    if (deviceId) {
      deleteOptions.deviceId = deviceId;
    }

    // 如果没有指定任何筛选条件，但有确认删除标志，允许删除所有数据
    if (!deleteOptions.dataTypes && !deleteOptions.startTime && !deleteOptions.endTime && !deleteOptions.deviceId) {
      console.log('清空所有数据操作，已确认删除'); // 调试日志
      // 设置默认值以删除所有数据
      deleteOptions.startTime = 0;
      deleteOptions.endTime = Date.now();
    }

    // 删除数据
    console.log('执行删除操作，选项:', deleteOptions); // 调试日志
    const result = await deleteData(deleteOptions);
    console.log('删除结果:', result); // 调试日志

    return res.json({
      success: true,
      message: '数据删除成功',
      deletedCount: result.deletedCount || 0,
      options: deleteOptions
    });

  } catch (error) {
    console.error('数据删除API错误:', error);
    res.status(500).json({ error: error.message || '数据删除失败' });
  }
});

// PDF报告导出API接口
app.post('/api/data/export/pdf', async (req, res) => {
  console.log('=== PDF Export API Called ===');
  try {
    console.log('Request body:', req.body);
    const {
      startTime,
      endTime,
      dataTypes,
      deviceId
    } = req.body;
    console.log('Extracted parameters:', { startTime, endTime, dataTypes, deviceId });

    // 参数验证
    if (!startTime || !endTime) {
      return res.status(400).json({ error: '请提供开始时间和结束时间' });
    }

    if (!dataTypes || !Array.isArray(dataTypes) || dataTypes.length === 0) {
      return res.status(400).json({ error: '请至少选择一种数据类型' });
    }

    // 验证数据类型
    const validDataTypes = ['Heart', 'DropRate', 'Temperature', 'n_spo2'];
    const invalidTypes = dataTypes.filter(type => !validDataTypes.includes(type));
    if (invalidTypes.length > 0) {
      return res.status(400).json({ error: `无效的数据类型: ${invalidTypes.join(', ')}` });
    }

    // 验证时间范围
    const startTimestamp = parseInt(startTime);
    const endTimestamp = parseInt(endTime);

    if (isNaN(startTimestamp) || isNaN(endTimestamp)) {
      return res.status(400).json({ error: '时间格式无效' });
    }

    if (startTimestamp >= endTimestamp) {
      return res.status(400).json({ error: '开始时间必须早于结束时间' });
    }

    // 查询数据
    const queryOptions = {
      startTime: startTimestamp,
      endTime: endTimestamp,
      dataTypes: dataTypes,
      limit: 1000 // PDF报告限制数据量
    };

    if (deviceId) {
      queryOptions.deviceId = deviceId;
    }

    const queryResult = await queryData(queryOptions);

    if (!queryResult || !queryResult.data || queryResult.data.length === 0) {
      return res.status(404).json({ error: '指定条件下没有找到数据' });
    }

    // 生成PDF
    console.log('开始生成PDF，数据量:', queryResult.data.length);
    console.log('PDF生成参数:', {
      dataLength: queryResult.data.length,
      startTime: startTimestamp,
      endTime: endTimestamp,
      dataTypes: dataTypes
    });

    const pdfGenerator = new PDFGenerator();
    const pdfBuffer = await pdfGenerator.generatePDF({
      data: queryResult.data,
      startTime: startTimestamp,
      endTime: endTimestamp,
      dataTypes: dataTypes
    });

    console.log('PDF生成完成，Buffer长度:', pdfBuffer.length);

    // 设置响应头
    const filename = `medical_report_${new Date().toISOString().slice(0, 10)}.pdf`;

    // 确保PDF Buffer是正确的格式
    console.log('PDF Buffer type:', typeof pdfBuffer);
    console.log('PDF Buffer is Buffer:', Buffer.isBuffer(pdfBuffer));
    console.log('PDF Buffer length:', pdfBuffer.length);
    console.log('PDF Buffer first 10 bytes:', pdfBuffer.subarray(0, 10));

    // 临时保存PDF文件，然后发送
    const fs = require('fs');
    const path = require('path');
    const tempFilePath = path.join(__dirname, 'temp', filename);

    // 确保temp目录存在
    const tempDir = path.dirname(tempFilePath);
    if (!fs.existsSync(tempDir)) {
      fs.mkdirSync(tempDir, { recursive: true });
    }

    // 保存PDF到临时文件
    fs.writeFileSync(tempFilePath, pdfBuffer);
    console.log('PDF saved to temp file:', tempFilePath);

    // 设置响应头并发送文件
    res.setHeader('Content-Type', 'application/pdf');
    res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);

    console.log(`PDF报告生成成功: ${filename}, 数据量: ${queryResult.data.length}条`);

    // 发送文件
    res.sendFile(tempFilePath, (err) => {
      if (err) {
        console.error('Error sending PDF file:', err);
      } else {
        console.log('PDF file sent successfully');
        // 删除临时文件
        setTimeout(() => {
          try {
            fs.unlinkSync(tempFilePath);
            console.log('Temp file deleted:', tempFilePath);
          } catch (deleteErr) {
            console.error('Error deleting temp file:', deleteErr);
          }
        }, 1000);
      }
    });

  } catch (error) {
    console.error('PDF导出API错误:', error);
    res.status(500).json({ error: error.message || 'PDF生成失败' });
  }
});

/**
 * 处理和存储WebSocket接收到的医疗数据
 * @param {string} message - WebSocket消息内容
 */
async function processAndStoreData(message) {
  try {
    // 解析医疗数据协议格式
    const medicalData = parseMedicalData(message);

    if (medicalData) {
      // 异步存储数据，不阻塞WebSocket消息处理
      await saveData(medicalData.dataType, medicalData.value, Date.now(), 'websocket');
      console.log(`WebSocket数据存储成功: ${medicalData.dataType}=${medicalData.value}`);
    }
  } catch (error) {
    // 存储失败不影响WebSocket广播功能，只记录错误日志
    console.error('WebSocket数据存储失败:', error.message);
  }
}

/**
 * 解析医疗数据协议格式
 * @param {string} message - 原始消息
 * @returns {Object|null} - 解析后的医疗数据对象或null
 */
function parseMedicalData(message) {
  try {
    const trimmedMessage = message.trim();

    // 支持的医疗数据协议格式
    const protocols = [
      { pattern: /^Heart:\s*(\d+)\s*$/i, dataType: 'Heart' },
      { pattern: /^DropRate:\s*(\d+)\s*$/i, dataType: 'DropRate' },
      { pattern: /^Temperature:\s*(\d+)\s*$/i, dataType: 'Temperature' },
      { pattern: /^n_spo2:\s*(\d+)\s*$/i, dataType: 'n_spo2' }
    ];

    // 尝试匹配各种协议格式
    for (const protocol of protocols) {
      const match = trimmedMessage.match(protocol.pattern);
      if (match) {
        const value = parseInt(match[1]);

        // 验证数值是否有效
        if (!isNaN(value) && value >= 0) {
          return {
            dataType: protocol.dataType,
            value: value,
            originalMessage: message
          };
        }
      }
    }

    return null; // 不是医疗数据格式
  } catch (error) {
    console.error('医疗数据解析错误:', error.message);
    return null;
  }
}

function startServer(port) {
  wss = new WebSocket.Server({ server });
  wss.on('connection', ws => {
    ws.on('message', message => {
      const messageStr = String(message);

      // 保持现有的广播功能不变
      wss.clients.forEach(client => {
        if (client !== ws && client.readyState === WebSocket.OPEN) {
          client.send(messageStr);
        }
      });

      // 异步处理数据存储，不影响广播功能
      processAndStoreData(messageStr);
    });
  });
  console.log(`WebSocket服务器已启动，监听端口：${port}`);
}

// 初始化数据库并启动服务器
async function startApplication() {
  try {
    // 初始化数据库
    await initDatabase();
    console.log('数据库初始化成功');

    // 测试数据库连接
    await testConnection();

    // 启动WebSocket服务器
    startServer(process.env.PORT || 8080);

    // 启动HTTP服务器
    server.listen(process.env.PORT || 8080, () => {
      console.log(`HTTP服务器和WebSocket服务器已启动，监听端口：${process.env.PORT || 8080}`);
      console.log(`前端请访问: http://localhost:${process.env.PORT || 8080}`);
    });

  } catch (error) {
    console.error('应用启动失败:', error);
    process.exit(1);
  }
}

// 启动应用
startApplication();